home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 52 / Amiga Format AFCD52 (Issue 136, May 2000).iso / -serious- / programming / other / mesa / mesa-aux / src-aux.aos / vect3d.c < prev    next >
C/C++ Source or Header  |  2000-02-23  |  3KB  |  181 lines
  1. /*
  2.  * vect3d.c 
  3.  */
  4.  
  5. /*
  6.  * Routines to manipulate 3 dimensional vectors.  All these routines
  7.  * * should work even if the input and output vectors are the same.
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <math.h>
  13. #include <GL/gl.h>
  14. #include "3d.h"
  15.  
  16. #if defined(__cplusplus) || defined(c_plusplus)
  17. #define class c_class
  18. #endif
  19.  
  20. void (*errfunc) (char *) = 0;
  21.  
  22. void seterrorfunc(void (*func) (char *))
  23. {
  24.   errfunc = func;
  25. }
  26.  
  27. void error(char *s)
  28. {
  29.   if (errfunc)
  30.     (*errfunc) (s);
  31.   else {
  32.     fprintf(stderr, s);
  33.     fprintf(stderr, "\n");
  34.     exit(1);
  35.   }
  36. }
  37.  
  38. void diff3(GLdouble p[3], GLdouble q[3], GLdouble diff[3])
  39. {
  40.   diff[0] = p[0] - q[0];
  41.   diff[1] = p[1] - q[1];
  42.   diff[2] = p[2] - q[2];
  43. }
  44.  
  45. void add3(GLdouble p[3], GLdouble q[3], GLdouble sum[3])
  46. {
  47.   sum[0] = p[0] + q[0];
  48.   sum[1] = p[1] + q[1];
  49.   sum[2] = p[2] + q[2];
  50. }
  51.  
  52. void scalarmult(GLdouble s, GLdouble v[3], GLdouble vout[3])
  53. {
  54.   vout[0] = v[0] * s;
  55.   vout[1] = v[1] * s;
  56.   vout[2] = v[2] * s;
  57. }
  58.  
  59. GLdouble dot3(GLdouble p[3], GLdouble q[3])
  60. {
  61.   return p[0] * q[0] + p[1] * q[1] + p[2] * q[2];
  62. }
  63.  
  64. GLdouble length3(GLdouble v[3])
  65. {
  66.   return sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
  67. }
  68.  
  69. GLdouble dist3(GLdouble p[3], GLdouble q[3])
  70. {
  71.   GLdouble d[3];
  72.  
  73.   diff3(p, q, d);
  74.   return length3(d);
  75. }
  76.  
  77. void copy3(GLdouble old[3], GLdouble new_c[3])
  78. {
  79.   new_c[0] = old[0], new_c[1] = old[1], new_c[2] = old[2];
  80. }
  81.  
  82. void crossprod(GLdouble v1[3], GLdouble v2[3], GLdouble prod[3])
  83. {
  84.   GLdouble p[3];                                   /*
  85.  
  86.                                             * in case prod == v1 or v2 
  87.                                             */
  88.  
  89.   p[0] = v1[1] * v2[2] - v2[1] * v1[2];
  90.   p[1] = v1[2] * v2[0] - v2[2] * v1[0];
  91.   p[2] = v1[0] * v2[1] - v2[0] * v1[1];
  92.   prod[0] = p[0];
  93.   prod[1] = p[1];
  94.   prod[2] = p[2];
  95. }
  96.  
  97. void normalize(GLdouble v[3])
  98. {
  99.   GLdouble d;
  100.  
  101.   d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
  102.   if (d == 0.0) {
  103.     error("normalize: zero length vector");
  104.     v[0] = d = 1.0;
  105.   }
  106.   d = 1 / d;
  107.   v[0] *= d;
  108.   v[1] *= d;
  109.   v[2] *= d;
  110. }
  111.  
  112. void print3(GLdouble v[3])
  113. {
  114.   GLdouble len;
  115.  
  116.   len = length3(v);
  117.   printf("(%g %g %g); len: %g\n", v[0], v[1], v[2], len);
  118. }
  119.  
  120. void printmat3(GLdouble m[3][3])
  121. {
  122.   int i, j;
  123.  
  124.   for (i = 0; i < 3; i++) {
  125.     for (j = 0; j < 3; j++)
  126.       printf("%7.4f  ", m[i][j]);
  127.     printf("\n");
  128.   }
  129. }
  130.  
  131. void identifymat3(GLdouble m[3][3])
  132. {
  133.   int i, j;
  134.  
  135.   for (i = 0; i < 3; i++)
  136.     for (j = 0; j < 3; j++)
  137.       m[i][j] = (i == j) ? 1.0 : 0.0;
  138. }
  139.  
  140. void copymat3(GLdouble * to, GLdouble * from)
  141. {
  142.   int i;
  143.  
  144.   for (i = 0; i < 9; i++) {
  145.     *to++ = *from++;
  146.   }
  147. }
  148.  
  149. void xformvec3(GLdouble v[3], GLdouble m[3][3], GLdouble vm[3])
  150. {
  151.   GLdouble result[3];                                   /*
  152.  
  153.                                             * in case v == vm 
  154.                                             */
  155.   int i;
  156.  
  157.   for (i = 0; i < 3; i++) {
  158.     result[i] = v[0] * m[0][i] + v[1] * m[1][i] + v[2] * m[2][i];
  159.   }
  160.   for (i = 0; i < 3; i++) {
  161.     vm[i] = result[i];
  162.   }
  163. }
  164.  
  165. long samepoint(GLdouble p1[3], GLdouble p2[3])
  166. {
  167.   if (p1[0] == p2[0] && p1[1] == p2[1] && p1[2] == p2[2])
  168.     return 1;
  169.   return 0;
  170. }
  171.  
  172. void perpnorm(GLdouble p1[3], GLdouble p2[3], GLdouble p3[3], GLdouble n[3])
  173. {
  174.   GLdouble d1[3], d2[3];
  175.  
  176.   diff3(p2, p1, d1);
  177.   diff3(p2, p3, d2);
  178.   crossprod(d1, d2, n);
  179.   normalize(n);
  180. }
  181.